﻿using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office.Interop.Word;
using System.IO;
using System.Diagnostics;

namespace ReadAndWrite
{
    /// <summary>
    /// Permet de gerer un fichier word
    /// </summary>
    public class Word : ReadAndWrite
    {
        #region Attributs
        /// <summary>
        /// Application Word
        /// </summary>
        _Application app;
        /// <summary>
        /// Docuement ouvert
        /// </summary>
        _Document nvDoc;
        /// <summary>
        /// Nom du document
        /// </summary>
        string fileName;
        //private int processId; 
        #endregion

        #region Constructeur
        /// <summary>
        /// Contructeur : Creer un objet Word
        /// </summary>
        public Word()
        {
            app = new Microsoft.Office.Interop.Word.Application();
            DesactiverAlerts();
            app.Visible = false; // mettez cette variable à true si vous souhaitez visualiser les opérations.
            nvDoc = null;

        }
        #endregion

        #region Methode sur l'application
        /// <summary>
        /// Permet d'afficher l'application Word
        /// </summary>
        /// <returns>La valeur d'affichage</returns>
        public bool Afficher()
        {
            try
            {
                ActiverAlerts();
                app.Visible = true;
                return app.Visible;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Permet de cacher l'application Word
        /// </summary>
        /// <returns>La valeur d'affichage</returns>
        public bool Cacher()
        {
            try
            {
                DesactiverAlerts();
                app.Visible = false;
                return app.Visible;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Fige le refresh de word
        /// </summary>
        /// <returns>la valeur du refresh</returns>
        public bool Geler()
        {
            try
            {
                app.ScreenUpdating = false;
                return app.ScreenUpdating;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Lance le refresh de word
        /// </summary>
        /// <returns>la valeur du refresh</returns>
        public bool DeGeler()
        {
            try
            {
                app.ScreenUpdating = true;
                return app.ScreenUpdating;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Desactive les messages d'alerte
        /// </summary>
        /// <returns>Vrai si la methode reussi</returns>
        public bool DesactiverAlerts()
        {
            try
            {
                app.DisplayAlerts = Microsoft.Office.Interop.Word.WdAlertLevel.wdAlertsNone;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Active les message d'alerte
        /// </summary>
        /// <returns>Vrai si la methode reussi</returns>
        public bool ActiverAlerts()
        {
            try
            {
                app.DisplayAlerts = Microsoft.Office.Interop.Word.WdAlertLevel.wdAlertsAll;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ferme l'application word
        /// </summary>
        /// <returns>Vrai si la methode reussi</returns>
        public bool Quitter()
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                // Fermeture de word
                object val = Microsoft.Office.Interop.Word.WdSaveOptions.wdDoNotSaveChanges;
                app.Quit(ref val, ref missing, ref missing);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Ferme l'application word
        /// </summary>
        /// <param name="save">Vrai le document est sauvegarder avant fermeture  </param> 
        /// <returns>Vrai si la methode reussi</returns>
        public bool Quitter(bool save)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                // Fermeture de word
                if (save)
                {
                    object val = Microsoft.Office.Interop.Word.WdSaveOptions.wdSaveChanges;
                    app.Quit(ref val, ref missing, ref missing);
                }
                else
                {
                    object val = Microsoft.Office.Interop.Word.WdSaveOptions.wdDoNotSaveChanges;
                    app.Quit(ref val, ref missing, ref missing);
                }
                return true;
            }
            catch (Exception) { throw; }
        }
        #endregion

        #region Méthode sur le document
        /// <summary>
        /// Ferme le document en cours
        /// </summary>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Fermer()
        {
            try
            {
                if (nvDoc != null)
                {
                    object missing = System.Reflection.Missing.Value;
                    // Fermeture de word
                    nvDoc.Close(ref missing, ref missing, ref missing);

                }
                return true;
            }
            catch (Exception) { throw; }

        }


        /// <summary>
        /// Ferme le document en cours
        /// </summary>
        /// <param name="save">Vrai le document est enregistré</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Fermer(bool save)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                if (nvDoc != null)
                {
                    if (save)
                    {
                        object wdsave = Microsoft.Office.Interop.Word.WdSaveOptions.wdSaveChanges;
                        nvDoc.Close(ref wdsave, ref missing, ref missing);
                    }
                    else
                    {
                        object wdsave = Microsoft.Office.Interop.Word.WdSaveOptions.wdDoNotSaveChanges;
                        // Fermeture de word
                        nvDoc.Close(ref wdsave, ref missing, ref missing);
                    }
                }
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Enregistre le document ouvert
        /// </summary>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Enregistrer()
        {
            try
            {
                if (nvDoc != null)
                {
                    nvDoc.Save();
                }
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Enregistre Sous
        /// </summary>
        /// <param name="Path">Le chemin du fichier</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Enregistrer(string Path)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                if (nvDoc != null)
                {
                    object file = Path;
                    nvDoc.SaveAs(ref file, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);
                    Path = System.IO.Path.GetFullPath(Path);
                    fileName = System.IO.Path.GetFileName(Path);
                }
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Ouvre le document word en paramétre
        /// </summary>
        /// <param name="Path">le chemin du document</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Ouvrir(string Path)
        {
            try
            {
                if (string.IsNullOrEmpty(Path))
                {
                    throw new ArgumentNullException("L'argument Path ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                if (System.IO.File.Exists(Path))
                {
                    object file = Path;
                    // ouvrir le document existant
                    nvDoc = app.Documents.Open(ref file, ref missing, ref missing,
                        ref missing, ref missing, ref missing, ref missing, ref missing,
                        ref missing, ref missing, ref missing, ref missing, ref missing,
                        ref missing, ref missing, ref missing);
                }
                else
                {
                    throw new ArgumentException("Le fichier n'existe pas : " + Path);
                }
                Path = System.IO.Path.GetFullPath(Path);
                fileName = System.IO.Path.GetFileName(Path);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Ouvrir le document en lecture seul
        /// </summary>
        /// <param name="Path"></param>
        /// <returns></returns>
        public bool OuvrirLectureSeule(string Path)
        {
            try
            {
                if (string.IsNullOrEmpty(Path))
                {
                    throw new ArgumentNullException("L'argument Path ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                if (System.IO.File.Exists(Path))
                {
                    object file = Path;
                    object readOnly = true;
                    // ouvrir le document existant
                    nvDoc = app.Documents.Open(ref file, ref missing, ref readOnly,
                        ref missing, ref missing, ref missing, ref missing, ref missing,
                        ref missing, ref missing, ref missing, ref missing, ref missing,
                        ref missing, ref missing, ref missing);

                    // Vérouille le document Word afin de bloquer sa modification une fois enregistré frauduleusement par l'utilisateur.
                    Object password = "plan";
                    nvDoc.Protect(WdProtectionType.wdAllowOnlyReading, ref missing, ref password, ref missing, ref missing);
                }
                else
                {
                    throw new ArgumentException("Le fichier n'existe pas : " + Path);
                }
                Path = System.IO.Path.GetFullPath(Path);
                fileName = System.IO.Path.GetFileName(Path);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Ouvre un docuement vide
        /// </summary>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Ouvrir()
        {
            try
            {
                object missing = System.Reflection.Missing.Value;

                object fileName = "normal.dot";
                // Créer le document
                nvDoc = app.Documents.Add(ref fileName, ref missing, ref missing,
                            ref missing);
                Path = System.IO.Path.GetFullPath(Path);
                fileName = System.IO.Path.GetFileName(Path);

                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Se déplace sur le signet
        /// </summary>
        /// <param name="signet">le signet du document</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool AllerA(string signet)
        {
            try
            {
                if (string.IsNullOrEmpty(signet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = signet;
                object pos = nvDoc.Bookmarks.get_Item(ref val).Start;
                nvDoc.Range(ref pos, ref pos).Select();
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Créér un signet
        /// </summary>
        /// <param name="nomSignet"></param>
        /// <returns></returns>
        public bool CreerSignet(string nomSignet)
        {
            try
            {
                if (string.IsNullOrEmpty(nomSignet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = nomSignet;

                object pos = app.Selection.Start;
                object rg = nvDoc.Range(ref pos, ref pos);
                nvDoc.Bookmarks.Add(nomSignet, ref rg);

                nvDoc.Range(ref pos, ref pos).Select();
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Aller à l'étiquette
        /// </summary>
        /// <param name="signet"></param>
        /// <returns></returns>
        public bool AllerAGoto(string signet)
        {
            try
            {
                if (string.IsNullOrEmpty(signet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = signet;
                object pos = nvDoc.Bookmarks.get_Item(ref val).Start;
                object what = WdGoToItem.wdGoToBookmark;
                if (Convert.ToInt32(pos) >= 0)
                {
                    nvDoc.Bookmarks.get_Item(ref val).Range.Select();
                    return true;
                }
                else
                {
                    throw new ArgumentNullException("Le signet " + signet + " n'existe pas");
                }
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Se déplace sur le signet
        /// </summary>
        /// <param name="tb">le tableau</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool AllerAFinTableau(Table tb)
        {
            try
            {
                object pos = tb.Range.End;
                nvDoc.Range(ref pos, ref pos).Select();


                return true;


            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajoute une ligne blanche dans le document
        /// </summary>
        /// <returns>Vrai si la methode reussi</returns>
        public bool AjouterLigne()
        {
            try
            {
                object pos = app.Selection.Start;
                Range rg = nvDoc.Range(ref pos, ref pos);
                rg.InsertParagraphBefore();
                //nvDoc.Paragraphs.Add(ref rg); 

                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Deplace le curseur sur la ligne de dessous
        /// </summary>
        /// <returns>Vrai si la methode reussi</returns>
        public bool DeplacerVersLeBas()
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                object pos = app.Selection.End;
                object unit = Microsoft.Office.Interop.Word.WdUnits.wdParagraph;
                object val = 1;
                app.Selection.MoveDown(ref unit, ref val, ref missing);

                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Redefinie la position d'un signet à l'endroit courant
        /// </summary>
        /// <param name="signet">le signet du document</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Redefinir(string signet)
        {
            try
            {
                if (string.IsNullOrEmpty(signet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = signet;
                Bookmark bks = nvDoc.Bookmarks.get_Item(ref val);
                bks.Delete();
                nvDoc.Bookmarks.Add(signet, ref missing);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ecrire dans le docuement
        /// </summary>
        /// <param name="message">le texte a écrire</param>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Ecrire(string message)
        {
            try
            {
                if (string.IsNullOrEmpty(message))
                {
                    throw new ArgumentNullException("L'argument message ne peut pas être null");
                }
                object msg = message;

                app.Selection.Text = message;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Definit la taille de la police d'écriture
        /// </summary>
        /// <param name="taille"></param>
        /// <returns></returns>
        public bool ModifierTaille(int taille)
        {
            try
            {
                if (taille == 0)
                {
                    throw new ArgumentNullException("L'argument taille ne peut pas être Zéro");
                }
                app.Selection.Font.Size = taille;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Definit la police d'écriture
        /// </summary>
        /// <param name="nom"></param>
        /// <returns></returns>
        public bool ModifierPolice(string nom)
        {
            try
            {
                if (string.IsNullOrEmpty(nom))
                {
                    throw new ArgumentNullException("L'argument nom ne peut pas être null");
                }
                app.Selection.Font.Name = nom;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Mise en gras ou non
        /// </summary>
        /// <returns></returns>
        public bool PoliceGras()
        {
            try
            {
                app.Selection.Font.Bold = Convert.ToInt32(WdConstants.wdToggle);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Mise en souligné ou non
        /// </summary>
        /// <returns></returns>
        public bool PoliceSouligne()
        {
            try
            {
                if (app.Selection.Font.Underline == WdUnderline.wdUnderlineNone)
                {
                    app.Selection.Font.Underline = WdUnderline.wdUnderlineSingle;
                }
                else
                {
                    app.Selection.Font.Underline = WdUnderline.wdUnderlineNone;
                }
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Retour si élément courant est souligné ou non
        /// </summary>
        /// <returns></returns>
        public bool IsSouligne()
        {
            try
            {
                if (app.Selection.Font.Underline == WdUnderline.wdUnderlineNone)
                {
                    return false;
                }
                else
                {
                    return true;
                }

            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Mise en Italic ou non
        /// </summary>
        /// <returns></returns>
        public bool PoliceItalic()
        {
            try
            {
                app.Selection.Font.Italic = Convert.ToInt32(WdConstants.wdToggle);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Permet de changer le style
        /// </summary>
        /// <param name="nom"></param>
        /// <returns></returns>
        public bool DefinirStyle(string nom)
        {
            try
            {
                if (string.IsNullOrEmpty(nom))
                {
                    throw new ArgumentNullException("L'argument nom ne peut pas être null");
                }
                object item = nom;
                object mStyle = nvDoc.Styles.get_Item(ref item);
                app.Selection.set_Style(ref mStyle);
                return true;
            }
            catch (Exception) { throw; }

        }
        /// <summary>
        /// Suppression avec la touche BackSpace
        /// </summary>
        /// <returns></returns>
        public bool Backspace()
        {
            try
            {
                app.Selection.TypeBackspace();
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// deplacement à la fin de la ligne
        /// </summary>
        /// <returns></returns>
        public bool FinLigne()
        {
            try
            {
                object unit = Microsoft.Office.Interop.Word.WdUnits.wdLine;
                object missing = System.Reflection.Missing.Value;
                app.Selection.EndKey(ref unit, ref missing);
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// deplacement vers le bas
        /// </summary>
        /// <returns></returns>
        public bool VersLeBas()
        {
            try
            {
                object unit = Microsoft.Office.Interop.Word.WdUnits.wdLine;
                object missing = System.Reflection.Missing.Value;
                object count = 1;
                app.Selection.MoveDown(ref unit, ref count, ref missing);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Création d'un tableau
        /// </summary>
        /// <returns>le tableau créé</returns>
        public Table CreerTableau()
        {
            object start = app.Selection.Start;
            return CreerTableau(nvDoc.Range(ref start, ref start));
        }

        /// <summary>
        /// Création d'un tableau
        /// </summary>
        /// <param name="ligne">nombre de ligne du tableau</param>
        /// <param name="colonne">nombre de colonne du tableau</param>
        /// <returns>le tableau créé</returns>
        public Table CreerTableau(int ligne, int colonne)
        {
            object start = app.Selection.Start;
            return CreerTableau(nvDoc.Range(ref start, ref start), ligne, colonne);
        }

        /// <summary>
        /// Création d'un tableau
        /// </summary>
        /// <returns>le tableau créé</returns>
        public Table CreerTableau(Range rg)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                return nvDoc.Tables.Add(rg, 1, 1, ref missing, ref missing);
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Création d'un tableau
        /// </summary>
        /// <param name="rg">selection</param>
        /// <param name="ligne">nombre de ligne du tableau</param>
        /// <param name="colonne">nombre de colonne du tableau</param>
        /// <returns>Le tableau créé</returns>
        public Table CreerTableau(Range rg, int ligne, int colonne)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                return nvDoc.Tables.Add(rg, ligne, colonne, ref missing, ref missing);
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Fusionne de plusieurs cellule 
        /// </summary>
        /// <param name="tb">le tableau</param>
        /// <param name="ligneDebut">la ligne de début de selection</param>
        /// <param name="colonneDebut">la colonne de début de selection</param>
        /// <param name="ligneFin">la ligne de fin de selection</param>
        /// <param name="colonneFin">la colonne de fin de selection</param>
        /// <returns>Vrai si la methode reussi</returns>
        public bool FusionneeCellule(Table tb, int ligneDebut, int colonneDebut, int ligneFin, int colonneFin)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                tb.Cell(ligneDebut, colonneDebut).Merge(tb.Cell(ligneFin, colonneFin));
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajoute une ligne au tableau
        /// </summary>
        /// <param name="tb">le tableau</param>
        /// <returns>Vrai si la methode reussi</returns>
        public bool AjouterLigne(Table tb)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                tb.Rows.Add(ref missing);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ajoute une ligne au tableau avant la ligne
        /// </summary>
        /// <param name="tb">le tableau</param>
        /// <param name="avantLigne">numero de ligne avant l'insertion</param>
        /// <returns>Vrai si la methode reussi</returns>
        public bool AjouterLigne(Table tb, int avantLigne)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                object ligne = tb.Rows[avantLigne];
                tb.Rows.Add(ref ligne);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Ecrire un texte dans la cellule
        /// </summary>
        /// <param name="tb">le tableau</param>
        /// <param name="ligne">la ligne</param>
        /// <param name="colonne">la colonne</param>
        /// <param name="message">le texte</param>
        /// <returns>Vrai si la methode reussi</returns>
        public bool EcrireCellule(Table tb, int ligne, int colonne, string message)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                object msg = message;
                tb.Rows[ligne].Cells[colonne].Range.InsertBefore(message);

                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Recupere le tableau en cours
        /// </summary>
        /// <returns>Le tableau</returns>
        public Table GetTable()
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                return app.Selection.Tables[1];
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Obtient une cellule
        /// </summary>
        /// <param name="tb">le tableau</param>
        /// <param name="ligne">la ligne</param>
        /// <param name="colonne">la colonne</param>
        /// <returns>La cellule demandée</returns>
        public Cell GetCellule(Table tb, int ligne, int colonne)
        {
            try
            {
                object missing = System.Reflection.Missing.Value;
                return tb.Rows[ligne].Cells[colonne];
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Positionne la case à cocher a vrai ou faux
        /// </summary>
        /// <param name="signet">Le nom de la case à cocher</param>
        /// <param name="val">la valeur de la case à cocher</param>
        /// <returns>Vrai si la methode reussi</returns>
        public bool Checked(string signet, bool val)
        {
            try
            {
                if (string.IsNullOrEmpty(signet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;

                if (val)
                {
                    Check(signet);
                }
                else
                {
                    UnCheck(signet);
                }
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Possitionne à vrai la case à cocher
        /// </summary>
        /// <param name="signet">Le nom de la case à cocher</param>
        /// <returns>Vrai si la methode reussi</returns>
        public bool Check(string signet)
        {
            try
            {
                if (string.IsNullOrEmpty(signet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = signet;
                CheckBox obj = nvDoc.FormFields.get_Item(ref val).CheckBox;
                obj.Default = true;

                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Possitionne à faux la case à cocher
        /// </summary>
        /// <param name="signet">Le nom de la case à cocher</param>
        /// <returns></returns>
        public bool UnCheck(string signet)
        {
            try
            {
                if (string.IsNullOrEmpty(signet))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = signet;
                CheckBox obj = (CheckBox)nvDoc.FormFields.get_Item(ref val).CheckBox;
                obj.Default = false;

                return true;
            }
            catch (Exception) { throw; }
        }



        /// <summary>
        /// Passage en modification entete et pied page
        /// </summary>
        /// <returns></returns>
        public bool ActiverEntetePiedPage()
        {
            try
            {
                nvDoc.ActiveWindow.ActivePane.View.SeekView = WdSeekView.wdSeekCurrentPageHeader;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        ///¨passage en mode normal
        /// </summary>
        /// <returns></returns>
        public bool DesactiverEntetePiedPage()
        {
            try
            {
                nvDoc.ActiveWindow.ActivePane.View.SeekView = WdSeekView.wdSeekMainDocument;
                return true;
            }
            catch (Exception) { throw; }
        }
        /// <summary>
        /// Passage en aperçu avant impression
        /// </summary>
        /// <returns></returns>
        public bool ApercuAvantImpression()
        {
            nvDoc.PrintPreview();
            return true;
        }

        private bool continuPreview;
        private bool retour;

        /// <summary>
        /// Passage en aperçu avant impression
        /// </summary>
        /// <param name="nombreCopie" ></param>
        /// <returns></returns>
        public bool ApercuAvantImpression(int nombreCopie)
        {
            retour = false;
            object missing = System.Reflection.Missing.Value;

            nvDoc.PrintPreview();
            nvDoc.Application.Visible = true;

            nvDoc.Application.DocumentBeforeClose += new Microsoft.Office.Interop.Word.ApplicationEvents4_DocumentBeforeCloseEventHandler(Application_DocumentBeforeClose);
            nvDoc.Application.DocumentBeforePrint += new Microsoft.Office.Interop.Word.ApplicationEvents4_DocumentBeforePrintEventHandler(Application_DocumentBeforePrint);

            continuPreview = true;
            retour = false;
            // Boucle d'attente de l'aperçu avant impression
            while (continuPreview)
            {
                System.Threading.Thread.Sleep(100);
            }

            // Boucle d'attente de la fin de l'impression
            while (Convert.ToBoolean(nvDoc.Application.BackgroundPrintingStatus))
            {
                System.Threading.Thread.Sleep(100);
            }

            return retour;
        }

        /// <summary>
        /// Ajout le filigrane passé en paramètre
        /// </summary>
        /// <returns>Vrai si la méthode réussi</returns>
        public bool Filigrane(string filigrane)
        {
            try
            {
                if (nvDoc != null)
                {
                    object missing = System.Reflection.Missing.Value;


                    nvDoc.Sections[1].Range.Select();
                    nvDoc.ActiveWindow.ActivePane.View.SeekView = Microsoft.Office.Interop.Word.WdSeekView.wdSeekCurrentPageHeader;
                    Shape shape = app.Selection.HeaderFooter.Shapes.AddTextEffect(Microsoft.Office.Core.MsoPresetTextEffect.msoTextEffect1,
                        filigrane, "Times New Roman", 1, Microsoft.Office.Core.MsoTriState.msoFalse, Microsoft.Office.Core.MsoTriState.msoFalse, 0, 0, ref missing);
                    shape.Select(ref missing);
                    shape.Name = "PowerPlusWaterMarkObject1";
                    shape.TextEffect.NormalizedHeight = Microsoft.Office.Core.MsoTriState.msoFalse;
                    shape.Line.Visible = Microsoft.Office.Core.MsoTriState.msoFalse;
                    shape.Fill.Visible = Microsoft.Office.Core.MsoTriState.msoTrue;
                    shape.Fill.Solid();
                    shape.Fill.ForeColor.RGB = (int)Microsoft.Office.Interop.Word.WdColor.wdColorGray25;
                    shape.Fill.Transparency = 0.5f;
                    shape.Rotation = 315.0f;
                    shape.LockAspectRatio = Microsoft.Office.Core.MsoTriState.msoTrue;
                    shape.Height = app.CentimetersToPoints(4.93f);
                    shape.Width = app.CentimetersToPoints(22.2f);
                    shape.WrapFormat.AllowOverlap = -1;
                    shape.WrapFormat.Side = Microsoft.Office.Interop.Word.WdWrapSideType.wdWrapBoth;
                    //shape.WrapFormat.Type = Microsoft.Office.Interop.Word.WdWrapType.wdWrapNone;
                    shape.WrapFormat.Type = Microsoft.Office.Interop.Word.WdWrapType.wdWrapNone;
                    //shape.RelativeHorizontalPosition = Microsoft.Office.Interop.Word.WdRelativeHorizontalPosition.wdRelativeHorizontalPositionMargin;
                    shape.RelativeHorizontalPosition = Microsoft.Office.Interop.Word.WdRelativeHorizontalPosition.wdRelativeHorizontalPositionColumn;
                    //shape.RelativeVerticalPosition = Microsoft.Office.Interop.Word.WdRelativeVerticalPosition.wdRelativeVerticalPositionMargin;
                    shape.RelativeVerticalPosition = Microsoft.Office.Interop.Word.WdRelativeVerticalPosition.wdRelativeVerticalPositionParagraph;
                    shape.Left = (float)Microsoft.Office.Interop.Word.WdShapePosition.wdShapeLeft;
                    //shape.Top = (float)Microsoft.Office.Interop.Word.WdShapePosition.wdShapeInside;
                    shape.Left = -45.2f;
                    shape.Top = 306.5f;
                    shape.Visible = Microsoft.Office.Core.MsoTriState.msoTrue;
                    nvDoc.ActiveWindow.ActivePane.View.SeekView = Microsoft.Office.Interop.Word.WdSeekView.wdSeekMainDocument;
                }
                return true;
            }
            catch (Exception) { throw; }

        }


        #endregion

        #region Evenement
        /// <summary>
        /// Réagit à la fermeture d'un document WORD
        /// </summary>
        /// <param name="Doc"></param>
        /// <param name="Cancel"></param>
        void Application_DocumentBeforeClose(Microsoft.Office.Interop.Word.Document Doc, ref bool Cancel)
        {
            retour = false;
            continuPreview = false;
            app.ActiveWindow.Application.DisplayAlerts = Microsoft.Office.Interop.Word.WdAlertLevel.wdAlertsNone;
            nvDoc.Application.Visible = false;
            return;
        }
        /// <summary>
        /// Réagit à l'impression d'un document word
        /// </summary>
        /// <param name="Doc"></param>
        /// <param name="Cancel"></param>
        void Application_DocumentBeforePrint(Microsoft.Office.Interop.Word.Document Doc, ref bool Cancel)
        {
            retour = true;
            continuPreview = false;
            //nvDoc.Application.Visible = false; 
            return;
        }
        #endregion

        #region Autres

        /// <summary>
        /// Atteindre le tableau specifié
        /// </summary>
        /// <param name="nom"></param>
        /// <returns></returns>
        public Table AllerTableau(string nom)
        {
            if (string.IsNullOrEmpty(nom))
            {
                throw new ArgumentNullException("L'argument signet ne peut pas être null");
            }

            foreach (Table tb in nvDoc.Tables)
            {
                if (tb.ID == nom)
                {
                    return tb;
                }
            }
            return null;
        }

        /// <summary>
        /// en petite majuscule
        /// </summary>
        /// <returns></returns>
        public bool PetiteMajuscule()
        {
            try
            {
                app.Selection.Font.SmallCaps = Convert.ToInt32(true);
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Centrer le texte
        /// </summary>
        /// <returns></returns>
        public bool CentrerTexte()
        {
            try
            {
                app.Selection.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphCenter;
                return true;
            }
            catch (Exception) { throw; }

        }

        /// <summary>
        /// Paragraphe solidaire
        /// </summary>
        /// <param name="nomSignetDebut"></param>
        /// <param name="nomSignetFin"></param>
        /// <returns></returns>
        public bool ParagrapheSolidaire(string nomSignetDebut, string nomSignetFin)
        {
            try
            {
                if (string.IsNullOrEmpty(nomSignetDebut))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                object missing = System.Reflection.Missing.Value;
                object val = nomSignetDebut;
                object posDebut = nvDoc.Bookmarks.get_Item(ref val).Start;

                if (string.IsNullOrEmpty(nomSignetFin))
                {
                    throw new ArgumentNullException("L'argument signet ne peut pas être null");
                }
                val = nomSignetFin;
                object posFin = nvDoc.Bookmarks.get_Item(ref val).Start;

                nvDoc.Range(ref posDebut, ref posFin).Select();
                app.Selection.ParagraphFormat.KeepWithNext = -1;
                nvDoc.Range(ref posFin, ref posFin).Select();
                app.Selection.ParagraphFormat.KeepWithNext = 0;
                return true;
            }
            catch (Exception) { throw; }
        }

        /// <summary>
        /// Renvoie la page courante de la selection
        /// </summary>
        /// <returns></returns>
        public int nbPageSelection()
        {
            return Convert.ToInt32(app.Selection.get_Information(WdInformation.wdActiveEndPageNumber));
        }

        #endregion

        #region Destructeur
        /// <summary>
        /// Detruit l'objet Word
        /// </summary>
        ~Word()
        {
            Dispose();
        }
        /// <summary>
        /// Liberation de l'application word
        /// </summary>
        public void Dispose()
        {

            app = null;

        }
        #endregion
    }
}
